export class StrUtil {
    /**
     * 检查字符串是否为空白
     */
    static isBlank(str: string | null | undefined): boolean {
        return str === null || str === undefined || str.trim() === '';
    }

    /**
     * 替换字符串中的所有目标子字符串
     * @param str 原始字符串
     * @param target 要替换的目标子字符串
     * @param replacement 替换后的字符串
     */
    static replaceAll(str: string, target: string, replacement: string): string {
        if (this.isBlank(str)) {
            return str || '';
        }
        return str.split(target).join(replacement);
    }

    /**
     * 将字符串转换为小写
     * @param str 原始字符串
     */
    static toLowerCase(str: string | null | undefined): string {
        return str?.toLowerCase() || '';
    }

    /**
     * 将字符串转换为大写
     * @param str 原始字符串
     */
    static toUpperCase(str: string | null | undefined): string {
        return str?.toUpperCase() || '';
    }

    /**
     * 截取字符串（支持安全处理）
     * @param str 原始字符串
     * @param start 起始索引
     * @param end 结束索引（可选）
     */
    static substring(str: string | null | undefined, start: number, end?: number): string {
        if (this.isBlank(str)) {
            return '';
        }
        return str.substring(start, end);
    }

    /**
     * 去除字符串两端的空格
     * @param str 原始字符串
     */
    static trim(str: string | null | undefined): string {
        return str?.trim() || '';
    }

    /**
     * 检查字符串是否以指定前缀开始
     * @param str 原始字符串
     * @param prefix 前缀
     */
    static startsWith(str: string | null | undefined, prefix: string): boolean {
        if (this.isBlank(str) || this.isBlank(prefix)) {
            return false;
        }
        return str.startsWith(prefix);
    }

    /**
     * 检查字符串是否以指定后缀结束
     * @param str 原始字符串
     * @param suffix 后缀
     */
    static endsWith(str: string | null | undefined, suffix: string): boolean {
        if (this.isBlank(str) || this.isBlank(suffix)) {
            return false;
        }
        return str.endsWith(suffix);
    }

    /**
     * 反转字符串
     * @param str 原始字符串
     */
    static reverse(str: string | null | undefined): string {
        if (this.isBlank(str)) {
            return '';
        }
        return str.split('').reverse().join('');
    }

    /**
     * 检查字符串是否包含目标子字符串
     * @param str 原始字符串
     * @param substring 要检查的子字符串
     */
    static contains(str: string | null | undefined, substring: string): boolean {
        if (this.isBlank(str) || this.isBlank(substring)) {
            return false;
        }
        return str.includes(substring);
    }

    /**
     * 重复字符串指定次数
     * @param str 原始字符串
     * @param count 重复次数
     */
    static repeat(str: string | null | undefined, count: number): string {
        if (this.isBlank(str)) {
            return '';
        }
        return str.repeat(count);
    }

    static splitRow(str, columnSize = 4) {
        // 如果输入为空，直接返回空数组
        if (!str) return '';
        // 用于存储分割后的结果
        const result = [];

        // 遍历字符串，按 columnSize 分割
        for (let i = 0; i < str.length; i += columnSize) {
            // 截取从 i 开始，长度为 columnSize 的子字符串
            const row = str.slice(i, i + columnSize);
            result.push(row);
        }

        return result.join('\n');
    }
}
